import 'package:flutter/material.dart';
import '../layouts/side_menu_item.dart';
// 只在Web平台导入js互操作库
import 'url_updater.dart'; // 我们将创建这个文件来处理平台差异
import 'dart:async'; // 导入异步流支持
import 'dart:io' as io show Platform;
import 'package:flutter/foundation.dart' show kIsWeb;

/// 应用路由管理器 - 单例模式
class AppRouter {
  /// 单例实例
  static final AppRouter _instance = AppRouter._internal();
  
  /// 获取单例实例
  factory AppRouter() => _instance;
  
  /// 内部构造函数
  AppRouter._internal() {
    // 初始化路由表
    initRoutes();
    
    // 在Web平台，设置URL变化监听器
    if (kIsWeb) {
      _setupWebUrlListener();
    }
  }
  
  /// 为Web平台设置URL变化监听器
  void _setupWebUrlListener() {
    // 注意: 这里使用了JS互操作，需要导入dart:js
    // 由于代码简洁性考虑，这里不实现详细逻辑
    print('为Web平台设置URL变化监听器');
  }
  
  /// 路由配置映射表 - 使用菜单项作为路由配置
  final Map<String, SideMenuItem> _routes = {};
  
  /// 路由变更通知流控制器
  final StreamController<String> _routeChangeController = StreamController<String>.broadcast();
  
  /// 当前活动路由
  String _currentRoute = 'home';
  
  /// 获取路由变更通知流
  Stream<String> get onRouteChange => _routeChangeController.stream;
  
  /// 获取当前活动路由
  String get currentRoute => _currentRoute;

  /// 获取路由配置
  SideMenuItem? getRouteConfig(String routeName) {
    print('查找路由配置: $routeName'); // 添加调试信息
    
    // 标准化路由名称（去掉前导斜杠）
    routeName = _normalizeRouteName(routeName);
    print('规范化后的路由: $routeName'); // 添加调试信息
    
    // 打印所有可用的路由以进行调试
    print('可用路由: ${_routes.keys.join(', ')}');
    
    // 1. 首先尝试精确匹配
    if (_routes.containsKey(routeName)) {
      print('找到精确匹配的路由'); // 添加调试信息
      return _routes[routeName];
    }
    
    // 2. 尝试查找路径部分匹配
    final List<String> parts = routeName.split('/');
    if (parts.isNotEmpty) {
      // 检查最后一部分
      final String lastPart = parts.last;
      if (_routes.containsKey(lastPart)) {
        print('找到匹配最后部分的路由: $lastPart'); // 添加调试信息
        return _routes[lastPart];
      }
      
      // 逐步构建路径并检查
      String currentPath = '';
      for (int i = 0; i < parts.length; i++) {
        if (i > 0) currentPath += '/';
        currentPath += parts[i];
        print('检查部分路径: $currentPath'); // 添加调试信息
        if (_routes.containsKey(currentPath)) {
          print('找到部分路径匹配的路由: $currentPath'); // 添加调试信息
          return _routes[currentPath];
        }
      }
    }
    
    // 3. 进行更灵活的匹配，考虑父子关系
    for (final entry in _routes.entries) {
      if (entry.value.page != null) {
        // 检查父路径关系
        final String normalizedKey = _normalizeRouteName(entry.key);
        if (normalizedKey.contains('/')) {
          final List<String> keyParts = normalizedKey.split('/');
          final List<String> routeParts = routeName.split('/');
          
          // 如果路由部件的最后部分匹配，并且父级路径结构类似，则考虑匹配
          if (keyParts.isNotEmpty && routeParts.isNotEmpty && 
              keyParts.last == routeParts.last) {
            print('找到基于结构的匹配路由: ${entry.key}'); // 添加调试信息
            return entry.value;
          }
        }
      }
    }
    
    print('未找到匹配的路由!'); // 添加调试信息
    return null;
  }

  /// 标准化路由名称（去掉前导斜杠）
  String _normalizeRouteName(String routeName) {
    return routeName.startsWith('/') ? routeName.substring(1) : routeName;
  }

  /// 初始化路由表
  void initRoutes() {
    print('初始化路由表'); // 添加调试信息
    
    // 清空现有路由
    _routes.clear();
    
    // 注册所有菜单项对应的路由
    _registerNestedRoutes(getSideMenuItems());
    
    // 单独为根路径注册首页
    _routes[''] = _routes['home'] ?? SideMenuItem(title: '首页', route: 'home');
    
    // 打印注册的路由信息
    print('注册的路由数量: ${_routes.length}');
    print('路由列表: ${_routes.keys.join(', ')}');
  }
  
  /// 递归注册嵌套路由
  void _registerNestedRoutes(List<SideMenuItem> items, [String parentPath = '']) {
    for (final item in items) {
      // 构建当前菜单项的完整路径
      String currentPath = parentPath.isEmpty 
          ? item.normalizedRoute // 使用标准化的路由
          : '$parentPath/${item.normalizedRoute}';
      
      // 确保路径没有多余的斜杠
      while (currentPath.contains('//')) {
        currentPath = currentPath.replaceAll('//', '/');
      }
      
      // 标准化路径
      currentPath = _normalizeRouteName(currentPath);
      
      print('注册路由: $currentPath -> ${item.title}'); // 添加调试信息
      
      // 同时注册标准路由和原始路由（保持向后兼容）
      if (item.page != null) {
        _routes[currentPath] = item;
        _routes[item.normalizedRoute] = item;
        
        // 对于多级路径，也注册其最后一部分（向后兼容）
        if (currentPath.contains('/')) {
          final parts = currentPath.split('/');
          final lastPart = parts.last;
          // 避免覆盖已有的路由项
          if (!_routes.containsKey(lastPart)) {
            _routes[lastPart] = item;
          }
          
          // 注册完整路径的变体，以支持不同的URL格式
          _registerPathVariants(currentPath, item);
        }
      }
      
      // 递归处理子菜单项
      if (item.hasChildren) {
        _registerNestedRoutes(item.children!, currentPath);
      }
    }
  }
  
  /// 注册路径的各种变体，以支持不同的URL格式
  void _registerPathVariants(String path, SideMenuItem item) {
    // 注册带前导斜杠的版本
    final withLeadingSlash = '/$path';
    // 注册不带前导斜杠的版本
    final withoutLeadingSlash = path.startsWith('/') ? path.substring(1) : path;
    
    print('注册路径变体: $withLeadingSlash, $withoutLeadingSlash -> ${item.title}');
    
    // 如果还没有注册这些变体，则注册它们
    if (!_routes.containsKey(withLeadingSlash)) {
      _routes[withLeadingSlash] = item;
    }
    if (!_routes.containsKey(withoutLeadingSlash)) {
      _routes[withoutLeadingSlash] = item;
    }
  }

  /// 获取所有路由配置
  Map<String, SideMenuItem> get routes => _routes;
  
  /// 获取页面标题
  String getPageTitle(String name) {
    name = _normalizeRouteName(name);
    return _routes[name]?.title ?? name;
  }
  
  /// 获取页面图标
  IconData? getPageIcon(String name) {
    name = _normalizeRouteName(name);
    return _routes[name]?.icon;
  }
  
  /// 根据路由名称查找其父路由
  String? findParentRoute(String routeName) {
    routeName = _normalizeRouteName(routeName);
    
    // 如果路径包含斜杠，说明有父路径
    if (routeName.contains('/')) {
      final parts = routeName.split('/');
      if (parts.length >= 2) {
        // 构建父路径（不包括最后一部分）
        final parentPath = parts.sublist(0, parts.length - 1).join('/');
        return parentPath;
      }
    }
    
    // 查找在菜单树中的父路径
    return _findParentInMenuTree(routeName);
  }
  
  /// 在菜单树中查找父路由
  String? _findParentInMenuTree(String routeName) {
    // 获取所有菜单项
    final menuItems = getSideMenuItems();
    
    // 递归查找
    String? parent = _findParentRecursive(menuItems, routeName);
    return parent;
  }
  
  /// 递归查找父路由
  String? _findParentRecursive(List<SideMenuItem> items, String routeName) {
    for (final item in items) {
      if (item.hasChildren) {
        for (final child in item.children!) {
          if (child.route == routeName || child.normalizedRoute == routeName) {
            return item.route;
          }
          
          // 继续递归查找
          if (child.hasChildren) {
            final foundParent = _findParentRecursive([child], routeName);
            if (foundParent != null) {
              return item.route; // 返回顶级父路由
            }
          }
        }
      }
    }
    return null;
  }

  /// 使用自定义过渡效果生成路由
  static Route<dynamic> generateRoute(RouteSettings settings) {
    final instance = AppRouter();
    final routeName = instance._normalizeRouteName(settings.name ?? '');
    final routeConfig = instance.getRouteConfig(routeName);

    if (routeConfig != null && routeConfig.page != null) {
      return PageRouteBuilder(
        settings: settings,
        pageBuilder: (context, animation, secondaryAnimation) => 
          routeConfig.page!,
        transitionsBuilder: (context, animation, secondaryAnimation, child) {
          const begin = Offset(1.0, 0.0);
          const end = Offset.zero;
          const curve = Curves.easeInOut;
          
          var tween = Tween(begin: begin, end: end).chain(
            CurveTween(curve: curve),
          );
          
          return SlideTransition(
            position: animation.drive(tween),
            child: child,
          );
        },
        transitionDuration: const Duration(milliseconds: 300),
      );
    }

    // 未找到路由时的默认处理
    return MaterialPageRoute(
      builder: (_) => Scaffold(
        body: Center(
          child: Text('未找到路由: ${settings.name}', 
            style: const TextStyle(color: Colors.red, fontSize: 18)),
        ),
      ),
    );
  }
  
  
  /// 只更新URL而不进行实际导航（适用于内部页面切换）
  /// 这个方法会直接修改浏览器URL，同时通知应用内导航系统
  static void updateUrl(String routeName) {
    print('更新URL: $routeName'); // 添加调试信息
    
    // 确保路由名称规范化
    if (!routeName.startsWith('/')) {
      routeName = '/$routeName';
    }
    
    // 调用平台特定的URL更新实现
    UrlUpdater.updateUrl(routeName);
    
    // 获取标准化路径，用于内部导航
    final normalizedPath = routeName.startsWith('/') 
        ? routeName.substring(1) 
        : routeName;
    
    print('发送路由变更通知: $normalizedPath'); // 添加调试信息
    
    // 更新当前路由并通知订阅者
    final instance = AppRouter();
    instance._currentRoute = normalizedPath;
    instance._routeChangeController.add(normalizedPath); // 发送通知
  }
  
  /// 替换当前页面
  static Future<T?> replaceTo<T>(BuildContext context, String routeName) {
    return Navigator.of(context).pushReplacementNamed(routeName);
  }
  
  /// 关闭到指定页面
  static void popUntil(BuildContext context, String routeName) {
    Navigator.of(context).popUntil(ModalRoute.withName(routeName));
  }
  
  /// 清理资源
  void dispose() {
    _routeChangeController.close();
  }
} 